{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "SaliencyMap.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H-aXxou_Zcup"
      },
      "source": [
        "# Setup"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LiWinGjFXVep"
      },
      "source": [
        "import warnings\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "import cv2\n",
        "from PIL import Image\n",
        "from matplotlib import pyplot as plt \n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import DataLoader\n",
        "from torch.utils.data import Dataset\n",
        "\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "warnings.filterwarnings(\"ignore\")"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K2kiHdXNX8eH"
      },
      "source": [
        "## Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rfKCU17vYKAJ"
      },
      "source": [
        "class CustomDataset(Dataset):\n",
        "    def __init__(self, images, labels, transform=None):\n",
        "        self.images = images\n",
        "        self.labels = labels\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.images)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        if torch.is_tensor(idx):\n",
        "            idx = idx.tolist()\n",
        "\n",
        "        img = np.array(self.images[idx])\n",
        "        img = Image.fromarray(img)\n",
        "\n",
        "        if self.transform:\n",
        "            img = self.transform(img)\n",
        "\n",
        "        label = torch.tensor(self.labels[idx]).type(torch.long)\n",
        "        sample = (img, label)\n",
        "\n",
        "        return sample"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aRmuxs4HYErH"
      },
      "source": [
        "def load_data(path='fer2013.csv'):\n",
        "    fer2013 = pd.read_csv(path)\n",
        "    emotion_mapping = {0: 'Angry', 1: 'Disgust', 2: 'Fear', 3: 'Happy', 4: 'Sad', 5: 'Surprise', 6: 'Neutral'}\n",
        "\n",
        "    return fer2013, emotion_mapping"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z3TVdzO_YGO_"
      },
      "source": [
        "def prepare_data(data):\n",
        "    \"\"\" Prepare data for modeling\n",
        "        input: data frame with labels und pixel data\n",
        "        output: image and label array \"\"\"\n",
        "\n",
        "    image_array = np.zeros(shape=(len(data), 48, 48))\n",
        "    image_label = np.array(list(map(int, data['emotion'])))\n",
        "\n",
        "    for i, row in enumerate(data.index):\n",
        "        image = np.fromstring(data.loc[row, 'pixels'], dtype=int, sep=' ')\n",
        "        image = np.reshape(image, (48, 48))\n",
        "        image_array[i] = image\n",
        "\n",
        "    return image_array, image_label"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cQx97atGYDA8"
      },
      "source": [
        "def get_dataloaders(path='fer2013.csv', bs=64):\n",
        "    \"\"\" Prepare train, val, & test dataloaders\n",
        "        Augment training data using:\n",
        "            - cropping\n",
        "            - shifting (vertical/horizental)\n",
        "            - horizental flipping\n",
        "            - rotation\n",
        "\n",
        "        input: path to fer2013 csv file\n",
        "        output: (Dataloader, Dataloader, Dataloader) \"\"\"\n",
        "\n",
        "    fer2013, emotion_mapping = load_data(path)\n",
        "\n",
        "    xtrain, ytrain = prepare_data(fer2013[fer2013['Usage'] == 'Training'])\n",
        "    xval, yval = prepare_data(fer2013[fer2013['Usage'] == 'PrivateTest'])\n",
        "    xtest, ytest = prepare_data(fer2013[fer2013['Usage'] == 'PublicTest'])\n",
        "\n",
        "    mu, st = 0, 255\n",
        "    test_transform = transforms.Compose([\n",
        "        transforms.Resize(40),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize(mean=(mu,), std=(st,))\n",
        "    ])\n",
        "\n",
        "    train = CustomDataset(xtrain, ytrain, test_transform)\n",
        "    val = CustomDataset(xval, yval, test_transform)\n",
        "    test = CustomDataset(xtest, ytest, test_transform)\n",
        "\n",
        "    trainloader = DataLoader(train, batch_size=bs, shuffle=True, num_workers=2)\n",
        "    valloader = DataLoader(val, batch_size=bs, shuffle=True, num_workers=2)\n",
        "    testloader = DataLoader(test, batch_size=bs, shuffle=True, num_workers=2)\n",
        "\n",
        "    return trainloader, valloader, testloader"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PwzQ8bI0AaXD"
      },
      "source": [
        "# Setup Dataset\n",
        "trainloader, valloader, testloader = get_dataloaders(bs=1)"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3X9msdtpYL3L"
      },
      "source": [
        "## Model Architecture"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I9aoI9iKrtEf"
      },
      "source": [
        "class Vgg(nn.Module):\n",
        "    def __init__(self, drop=0.2):\n",
        "        super().__init__()\n",
        "\n",
        "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, padding=1)\n",
        "        self.conv1b = nn.Conv2d(64, out_channels=64, kernel_size=3, padding=1)\n",
        "\n",
        "        self.conv2a = nn.Conv2d(64, 128, 3, padding=1)\n",
        "        self.conv2b = nn.Conv2d(128, 128, 3, padding=1)\n",
        "\n",
        "        self.conv3a = nn.Conv2d(128, 256, 3, padding=1)\n",
        "        self.conv3b = nn.Conv2d(256, 256, 3, padding=1)\n",
        "\n",
        "        self.conv4a = nn.Conv2d(256, 512, 3, padding=1)\n",
        "        self.conv4b = nn.Conv2d(512, 512, 3, padding=1)\n",
        "\n",
        "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
        "\n",
        "        self.bn1a = nn.BatchNorm2d(64)\n",
        "        self.bn1b = nn.BatchNorm2d(64)\n",
        "\n",
        "        self.bn2a = nn.BatchNorm2d(128)\n",
        "        self.bn2b = nn.BatchNorm2d(128)\n",
        "\n",
        "        self.bn3a = nn.BatchNorm2d(256)\n",
        "        self.bn3b = nn.BatchNorm2d(256)\n",
        "\n",
        "        self.bn4a = nn.BatchNorm2d(512)\n",
        "        self.bn4b = nn.BatchNorm2d(512)\n",
        "\n",
        "        self.lin1 = nn.Linear(512 * 2 * 2, 4096)\n",
        "        self.lin2 = nn.Linear(4096, 4096)\n",
        "\n",
        "        self.lin3 = nn.Linear(4096, 7)\n",
        "\n",
        "        self.drop = nn.Dropout(p=drop)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = F.relu(self.bn1a(self.conv1a(x)))\n",
        "        x = F.relu(self.bn1b(self.conv1b(x)))\n",
        "        x = self.pool(x)\n",
        "\n",
        "        x = F.relu(self.bn2a(self.conv2a(x)))\n",
        "        x = F.relu(self.bn2b(self.conv2b(x)))\n",
        "        x = self.pool(x)\n",
        "\n",
        "        x = F.relu(self.bn3a(self.conv3a(x)))\n",
        "        x = F.relu(self.bn3b(self.conv3b(x)))\n",
        "        x = self.pool(x)\n",
        "\n",
        "        x = F.relu(self.bn4a(self.conv4a(x)))\n",
        "        x = F.relu(self.bn4b(self.conv4b(x)))\n",
        "        x = self.pool(x)\n",
        "        \n",
        "        x = x.view(-1, 512 * 2 * 2)\n",
        "        x = F.relu(self.drop(self.lin1(x)))\n",
        "        x = F.relu(self.drop(self.lin2(x)))\n",
        "        x = self.lin3(x)\n",
        "\n",
        "        return x"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ftIu5uNeryFT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "905acad4-4798-4995-ed70-8f3d4e31ed33"
      },
      "source": [
        "# Load Trained Model\n",
        "checkpoint = torch.load('VGGNet')\n",
        "\n",
        "net = Vgg().to(device)\n",
        "net.load_state_dict(checkpoint[\"params\"])\n",
        "net.eval()"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Vgg(\n",
              "  (conv1a): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv1b): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv2a): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv2b): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv3a): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv3b): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv4a): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (conv4b): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
              "  (bn1a): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (bn1b): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (bn2a): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (bn2b): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (bn3a): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (bn3b): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (bn4a): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (bn4b): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (lin1): Linear(in_features=2048, out_features=4096, bias=True)\n",
              "  (lin2): Linear(in_features=4096, out_features=4096, bias=True)\n",
              "  (lin3): Linear(in_features=4096, out_features=7, bias=True)\n",
              "  (drop): Dropout(p=0.2, inplace=False)\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GkMIU0PwZmaE"
      },
      "source": [
        "# Saliency Analysis"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TPNZIjxNqYaH",
        "outputId": "03a1595b-a975-4784-965b-b359c5bc4227"
      },
      "source": [
        "# get image from trainloader\n",
        "image, label = next(iter(trainloader))\n",
        "image_plt = torch.squeeze(image)\n",
        "\n",
        "# activate gradients for input/image\n",
        "image = image.to(device)\n",
        "image.requires_grad_()\n",
        "print(image.requires_grad)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "amz42JBjun2s",
        "outputId": "386a8d3e-c4e8-4fc4-c556-68cf8b46c1aa"
      },
      "source": [
        "# pass image through network\n",
        "output = net(image)\n",
        "\n",
        "# get prediction and score\n",
        "prediction = output.argmax()\n",
        "output_max = output[0, prediction]\n",
        "\n",
        "# backprop score\n",
        "output_max.backward()\n",
        "\n",
        "# calculate saliency\n",
        "saliency, _ = torch.max(image.grad.data.abs(), dim=1) \n",
        "saliency = saliency.reshape(40, 40)\n",
        "\n",
        "# rescale between 0 and 1\n",
        "saliency -= saliency.min(1, keepdim=True)[0]\n",
        "saliency /= saliency.max(1, keepdim=True)[0]\n",
        "\n",
        "print(\"Ground Truth:\", label)\n",
        "print(\"Prediction:\", prediction)"
      ],
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ground Truth: tensor([3])\n",
            "Prediction: tensor(3, device='cuda:0')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 361
        },
        "id": "CqFJX-b6vFEn",
        "outputId": "67b29b48-27f8-4670-a103-48844081b73b"
      },
      "source": [
        "fig, axs = plt.subplots(nrows=1, ncols=3, figsize=(15,5))\n",
        "plt.tight_layout()\n",
        "\n",
        "axs[0].set_title('Original Image', fontsize=18)\n",
        "axs[0].imshow(image_plt, cmap = 'gray')\n",
        "axs[0].axis('off')\n",
        "\n",
        "axs[1].set_title('Saliency Map', fontsize=18)\n",
        "im = axs[1].imshow(saliency.cpu(), cmap='Blues')\n",
        "axs[1].axis('off')\n",
        "\n",
        "axs[2].set_title('Superimposed Saliency Map', fontsize=18)\n",
        "axs[2].imshow(image_plt, cmap = 'gray')\n",
        "axs[2].imshow(saliency.cpu(), cmap='Blues', alpha=0.4)\n",
        "axs[2].axis('off')\n",
        "\n",
        "cbar = fig.colorbar(im, ax=axs.ravel().tolist())\n",
        "for t in cbar.ax.get_yticklabels():\n",
        "     t.set_fontsize(12)\n",
        "\n",
        "plt.savefig(\"saliency.png\", bbox_inches = 'tight')\n",
        "plt.show()"
      ],
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x360 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gognlcW3t-R1"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}